package com.event.management.backend.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.event.management.backend.domain.*;
import com.event.management.backend.dto.QuestionnaireAnswerDTO;
import com.event.management.backend.dto.QuestionnaireQueryParam;
import com.event.management.backend.dto.QuestionnaireQuestionDTO;
import com.event.management.backend.dto.QuestionnaireTemplateDTO;
import com.event.management.backend.mapper.*;
import com.event.management.backend.service.QuestionnaireService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 问卷服务实现类
 */
@Service
public class QuestionnaireServiceImpl extends ServiceImpl<QuestionnaireTemplateMapper, QuestionnaireTemplate> implements QuestionnaireService {

    @Autowired
    private QuestionnaireQuestionMapper questionMapper;

    @Autowired
    private QuestionnaireAnswerMapper answerMapper;

    @Autowired
    private EventQuestionnaireMapper eventQuestionnaireMapper;

    @Autowired
    private ObjectMapper objectMapper;

    @Autowired
    private UsersMapper usersMapper;

    @Override
    public IPage<QuestionnaireTemplateDTO> getQuestionnairePage(QuestionnaireQueryParam queryParam) {
        // 构建分页参数
        Page<QuestionnaireTemplate> page = new Page<>(queryParam.getPageNum(), queryParam.getPageSize());

        // 构建查询条件
        LambdaQueryWrapper<QuestionnaireTemplate> queryWrapper = new LambdaQueryWrapper<>();

        // 关键词搜索（标题）
        if (StringUtils.hasText(queryParam.getKeyword())) {
            queryWrapper.like(QuestionnaireTemplate::getTitle, queryParam.getKeyword());
        }

        // 按创建者筛选
        if (queryParam.getCreatorId() != null) {
            queryWrapper.eq(QuestionnaireTemplate::getCreatorId, queryParam.getCreatorId());
        }

        // 活动ID筛选（通过关联表查询）
        if (queryParam.getEventId() != null) {
            // 查询该活动关联的模板ID列表
            List<QuestionnaireTemplate> templates = baseMapper.findTemplatesByEventId(queryParam.getEventId());
            if (templates.isEmpty()) {
                // 如果没有关联模板，返回空结果
                return new Page<>(queryParam.getPageNum(), queryParam.getPageSize());
            }
            List<Long> templateIds = templates.stream().map(QuestionnaireTemplate::getId).collect(Collectors.toList());
            queryWrapper.in(QuestionnaireTemplate::getId, templateIds);
        }
        
/*        // 如果当前用户不是管理员，只能查看自己创建的模板
        if (!StpUtil.hasRole("admin")) {
            queryWrapper.eq(QuestionnaireTemplate::getCreatorId, StpUtil.getLoginIdAsLong());
        }*/

        // 默认按创建时间降序排序
        queryWrapper.orderByDesc(QuestionnaireTemplate::getCreatedAt);

        // 执行查询
        IPage<QuestionnaireTemplate> resultPage = this.page(page, queryWrapper);

        // 转换为DTO
        List<QuestionnaireTemplateDTO> records = resultPage.getRecords().stream()
                .map(this::convertTemplateToDTO)
                .collect(Collectors.toList());

        // 构建返回结果
        IPage<QuestionnaireTemplateDTO> dtoPage = new Page<>(
                resultPage.getCurrent(),
                resultPage.getSize(),
                resultPage.getTotal()
        );
        dtoPage.setRecords(records);

        return dtoPage;
    }

    @Override
    public QuestionnaireTemplateDTO getQuestionnaireById(Long id) {
        if (id == null) {
            return null;
        }

        // 查询模板基本信息
        QuestionnaireTemplate template = getById(id);
        if (template == null || template.getIsDeleted()) {
            return null;
        }

        // 查询模板下的所有题目
        List<QuestionnaireQuestion> questions = questionMapper.findByTemplateId(id);

        // 转换为DTO
        QuestionnaireTemplateDTO templateDTO = convertTemplateToDTO(template);

        // 转换题目列表
        List<QuestionnaireQuestionDTO> questionDTOList = questions.stream()
                .map(this::convertQuestionToDTO)
                .collect(Collectors.toList());

        templateDTO.setQuestions(questionDTOList);

        return templateDTO;
    }

    @Override
    @Transactional
    public Long addQuestionnaire(QuestionnaireTemplateDTO questionnaireDTO) {
        // 创建模板实体
        QuestionnaireTemplate template = new QuestionnaireTemplate();
        BeanUtils.copyProperties(questionnaireDTO, template);

        // 设置创建者ID为当前登录用户
        template.setCreatorId(StpUtil.getLoginIdAsLong());

        // 保存模板
        boolean success = save(template);
        if (!success) {
            throw new RuntimeException("创建问卷模板失败");
        }

        // 保存题目
        if (questionnaireDTO.getQuestions() != null && !questionnaireDTO.getQuestions().isEmpty()) {
            saveQuestions(template.getId(), questionnaireDTO.getQuestions());
        }

        return template.getId();
    }

    @Override
    @Transactional
    public boolean updateQuestionnaire(Long id, QuestionnaireTemplateDTO questionnaireDTO) {
        // 查询模板是否存在
        QuestionnaireTemplate template = getById(id);
        if (template == null || template.getIsDeleted()) {
            return false;
        }

        // 更新模板基本信息，保留创建者ID
        Long creatorId = template.getCreatorId();
        BeanUtils.copyProperties(questionnaireDTO, template);
        template.setId(id);
        template.setCreatorId(creatorId);

        // 更新模板
        boolean success = updateById(template);
        if (!success) {
            return false;
        }

        // 删除原有题目
        LambdaQueryWrapper<QuestionnaireQuestion> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(QuestionnaireQuestion::getTemplateId, id);
        questionMapper.delete(queryWrapper);

        // 保存新题目
        if (questionnaireDTO.getQuestions() != null && !questionnaireDTO.getQuestions().isEmpty()) {
            saveQuestions(id, questionnaireDTO.getQuestions());
        }

        return true;
    }

    @Override
    @Transactional
    public boolean deleteQuestionnaire(Long id) {
        // 逻辑删除模板（题目通过外键级联删除）
        return removeById(id);
    }

    @Override
    @Transactional
    public boolean associateToEvent(Long eventId, Long templateId) {
        // 检查关联是否已存在
        int count = eventQuestionnaireMapper.checkRelationExists(eventId, templateId);
        if (count > 0) {
            // 已存在关联，直接返回成功
            return true;
        }

        // 创建新关联
        EventQuestionnaire relation = new EventQuestionnaire();
        relation.setEventId(eventId);
        relation.setTemplateId(templateId);
        relation.setIsActive(true); // 设置为启用状态

        return eventQuestionnaireMapper.insert(relation) > 0;
    }

    @Override
    public IPage<QuestionnaireAnswerDTO> getQuestionnaireResults(Long eventId, Integer pageNum, Integer pageSize) {
        // 构建分页参数
        Page<QuestionnaireAnswer> page = new Page<>(pageNum, pageSize);

        // 查询问卷提交记录
        IPage<QuestionnaireAnswer> resultPage = answerMapper.findAnswersByEventId(page, eventId);

        // 转换为DTO
        List<QuestionnaireAnswerDTO> records = resultPage.getRecords().stream()
                .map(this::convertAnswerToDTO)
                .collect(Collectors.toList());

        // 构建返回结果
        IPage<QuestionnaireAnswerDTO> dtoPage = new Page<>(
                resultPage.getCurrent(),
                resultPage.getSize(),
                resultPage.getTotal()
        );
        dtoPage.setRecords(records);

        return dtoPage;
    }

    @Override
    @Transactional
    public boolean submitQuestionnaire(QuestionnaireAnswerDTO answerDTO) {
        // 创建答案实体
        QuestionnaireAnswer answer = new QuestionnaireAnswer();
        answer.setEventId(answerDTO.getEventId());
        answer.setUserId(StpUtil.getLoginIdAsLong());

        try {
            // 将Map转换为JSON字符串存储
            answer.setAnswersJson(objectMapper.writeValueAsString(answerDTO.getAnswers()));
        } catch (JsonProcessingException e) {
            throw new RuntimeException("处理答案数据失败：" + e.getMessage());
        }

        return answerMapper.insert(answer) > 0;
    }

    @Override
    public boolean checkTemplateManagePermission(Long templateId) {
        // 获取当前登录用户ID
        Long userId = StpUtil.getLoginIdAsLong();

        // 如果是管理员，直接返回true
        if (StpUtil.hasRole("admin")) {
            return true;
        }

        // 检查是否是模板创建者
        int count = baseMapper.checkIsTemplateCreator(templateId, userId);
        return count > 0;
    }

    /**
     * 查询用户问卷提交记录
     *
     * @param userId     用户ID
     * @param eventId    活动ID
     * @param templateId 问卷模板ID
     * @param pageNum    页码
     * @param pageSize   每页条数
     * @return 问卷提交记录列表
     */
    @Override
    public IPage<QuestionnaireAnswerDTO> getUserQuestionnaireSubmissions(Long userId, Long eventId, Long templateId, Integer pageNum, Integer pageSize) {
        // 构建分页参数
        Page<QuestionnaireAnswer> page = new Page<>(pageNum, pageSize);

        // 构建查询条件
        LambdaQueryWrapper<QuestionnaireAnswer> queryWrapper = new LambdaQueryWrapper<>();

        // 添加筛选条件
        if (userId != null) {
            queryWrapper.eq(QuestionnaireAnswer::getUserId, userId);
        }

        if (eventId != null) {
            queryWrapper.eq(QuestionnaireAnswer::getEventId, eventId);
        }

        if (templateId != null) {
            queryWrapper.eq(QuestionnaireAnswer::getTemplateId, templateId);
        }

        // 按提交时间降序排序
        queryWrapper.orderByDesc(QuestionnaireAnswer::getSubmittedAt);

        // 执行查询
        IPage<QuestionnaireAnswer> resultPage = answerMapper.selectPage(page, queryWrapper);

        // 转换为DTO
        List<QuestionnaireAnswerDTO> records = resultPage.getRecords().stream()
                .map(this::convertAnswerToDTO)
                .collect(Collectors.toList());

        // 构建返回结果
        IPage<QuestionnaireAnswerDTO> dtoPage = new Page<>(
                resultPage.getCurrent(),
                resultPage.getSize(),
                resultPage.getTotal()
        );
        dtoPage.setRecords(records);

        return dtoPage;
    }

    /**
     * 保存问卷题目列表
     *
     * @param templateId 模板ID
     * @param questions  题目列表
     */
    private void saveQuestions(Long templateId, List<QuestionnaireQuestionDTO> questions) {
        for (int i = 0; i < questions.size(); i++) {
            QuestionnaireQuestionDTO questionDTO = questions.get(i);
            QuestionnaireQuestion question = new QuestionnaireQuestion();
            BeanUtils.copyProperties(questionDTO, question);

            // 设置模板ID
            question.setTemplateId(templateId);

            // 设置排序值（如果未设置）
            if (question.getSortOrder() == null) {
                question.setSortOrder(i + 1);
            }

            // 处理选项
            if (questionDTO.getOptions() != null && !questionDTO.getOptions().isEmpty()) {
                try {
                    question.setOptionsJson(objectMapper.writeValueAsString(questionDTO.getOptions()));
                } catch (JsonProcessingException e) {
                    throw new RuntimeException("处理选项数据失败：" + e.getMessage());
                }
            }

            // 保存题目
            questionMapper.insert(question);
        }
    }

    /**
     * 将模板实体转换为DTO
     *
     * @param template 模板实体
     * @return 模板DTO
     */
    private QuestionnaireTemplateDTO convertTemplateToDTO(QuestionnaireTemplate template) {
        if (template == null) {
            return null;
        }

        QuestionnaireTemplateDTO templateDTO = new QuestionnaireTemplateDTO();
        BeanUtils.copyProperties(template, templateDTO);

        // 获取创建者姓名
        if (template.getCreatorId() != null) {
            try {
                // 从Users表获取用户名
                Users user = usersMapper.selectById(template.getCreatorId());
                if (user != null) {
                    templateDTO.setCreatorName(user.getUsername());
                }
            } catch (Exception e) {
                // 出现异常时，设置一个默认值
                templateDTO.setCreatorName("未知用户");
            }
        }

        return templateDTO;
    }

    /**
     * 将题目实体转换为DTO
     *
     * @param question 题目实体
     * @return 题目DTO
     */
    private QuestionnaireQuestionDTO convertQuestionToDTO(QuestionnaireQuestion question) {
        if (question == null) {
            return null;
        }

        QuestionnaireQuestionDTO questionDTO = new QuestionnaireQuestionDTO();
        BeanUtils.copyProperties(question, questionDTO);

        // 处理选项
        if (StringUtils.hasText(question.getOptionsJson())) {
            try {
                List<String> options = objectMapper.readValue(question.getOptionsJson(),
                        objectMapper.getTypeFactory().constructCollectionType(List.class, String.class));
                questionDTO.setOptions(options);
            } catch (JsonProcessingException e) {
                // 如果解析失败，设置空列表
                questionDTO.setOptions(new ArrayList<>());
            }
        }

        return questionDTO;
    }

    /**
     * 将答案实体转换为DTO
     *
     * @param answer 答案实体
     * @return 答案DTO
     */
    @SuppressWarnings("unchecked")
    private QuestionnaireAnswerDTO convertAnswerToDTO(QuestionnaireAnswer answer) {
        if (answer == null) {
            return null;
        }

        QuestionnaireAnswerDTO answerDTO = new QuestionnaireAnswerDTO();
        BeanUtils.copyProperties(answer, answerDTO);

        // 处理答案内容
        if (StringUtils.hasText(answer.getAnswersJson())) {
            try {
                Map<String, Object> answers = objectMapper.readValue(answer.getAnswersJson(), Map.class);
                answerDTO.setAnswers(answers);
            } catch (JsonProcessingException e) {
                // 如果解析失败，设置空Map
                answerDTO.setAnswers(new HashMap<>());
            }
        }

        // 查询用户名称
        if (answer.getUserId() != null) {
            try {
                // 从Users表获取用户名
                Users user = usersMapper.selectById(answer.getUserId());
                if (user != null) {
                    answerDTO.setUserName(user.getUsername());
                }
            } catch (Exception e) {
                answerDTO.setUserName("未知用户");
            }
        }

        // 查询问卷模板标题
        if (answer.getTemplateId() != null) {
            try {
                // 从问卷模板表获取标题
                QuestionnaireTemplate template = this.getById(answer.getTemplateId());
                if (template != null) {
                    answerDTO.setTemplateTitle(template.getTitle());
                }
            } catch (Exception e) {
                answerDTO.setTemplateTitle("未知问卷");
            }
        }

        return answerDTO;
    }
} 